package com.rui.shangXueTang.stack;

/**
 * @author : [锐神NO.3]
 * @version : [v1.0]
 * @className : CalculateTest
 * @createTime : [2022/2/13 17:35]
 * @description : [描述该类的功能]
 */

@SuppressWarnings("all")
public class CalculateTest {
    public static void main(String[] args) {

        String str = "1+2*3-6/2";

        /*需要遍历字符串，获取每一个字符
        判断当前字符是一个运算符还是一个数字
        把数字放入数字栈，把运算符放入运算符栈
        运算符栈，如果是空栈，直接入帐，如果运算符栈中已经有了其他运算符就需要相对比运算符的优先级，新进来的运算符如果小于等于栈首运算符的优先级，先进行弹栈计算，计算结果再次入栈，如果大于，则直接入栈*/

        // 创建一个数字栈
        ArrayStack numStack = new ArrayStack(10);

        // 创建一个运算符栈
        ArrayStack symbolStack = new ArrayStack(10);

        int num1 = 0;
        int numn2 = 0;
        int symbol;
        int result = 0;

        String values = "";

        for(int i = 0; i < str.length(); i++){
            char c = str.charAt(i);
            //是否是一个运算符
            if(symbolStack.isOper(c)){
                //如果不是一个空栈
                if(!symbolStack.isEmpty()){
                    //比较优先级
                    if(symbolStack.priority(c) <= symbolStack.priority(symbolStack.peek())){
                        //弹栈计算，符号栈弹栈，数字栈弹栈
                        num1 = numStack.pop();
                        numn2 = numStack.pop();
                        symbol = symbolStack.pop();
                        result = numStack.calculate(num1, numn2, symbol);

                        //把计算结果再次入栈
                        numStack.push(result);

                        //把当前符号压入符号栈中
                        symbolStack.push(c);
                    }else {
                        //如果优先级大于等于栈顶符号，直接入栈
                        symbolStack.push(c);
                    }
                }else {
                    //如果是一个空栈，直接入栈
                    symbolStack.push(c);
                }
            }else {
                //如果是一个数字
                values += c;
                if(i == str.length() - 1){
                    //如果是最后一个字符，直接入栈
                    numStack.push(Integer.parseInt(values));
                }else {
                    //如果不是最后一个字符，判断下一个字符是否是一个运算符
                    if(symbolStack.isOper(str.charAt(i + 1))){
                        //如果是一个运算符，直接入栈
                        numStack.push(Integer.parseInt(values));
                        values = "";
                    }
                }
            }
        }

        while (true){
            if(symbolStack.isEmpty()){
                break;
            }
            num1 = numStack.pop();
            numn2 = numStack.pop();
            symbol = symbolStack.pop();
            result = numStack.calculate(num1, numn2, symbol);
            numStack.push(result);
        }

        int res = numStack.pop();
        System.out.println("结果是:" + res);
    }
}
